Page({
  data: {
    account: '',
    password: '',
    canLogin: false
  },

  onLoad() {
  },

  onAccountInput(e) {
    const account = e.detail.value;
    this.setData({ 
      account,
      canLogin: this.checkCanLogin(account, this.data.password)
    });
  },

  onPasswordInput(e) {
    const password = e.detail.value;
    this.setData({ 
      password,
      canLogin: this.checkCanLogin(this.data.account, password)
    });
  },

  checkCanLogin(account, password) {
    return account.length >= 3 && password.length >= 6;
  },

  onLogin() {
    const { account, password } = this.data;
    
    if (!this.checkCanLogin(account, password)) {
      wx.showToast({ title: '请填写完整信息', icon: 'none' });
      return;
    }

    // 验证账号格式（至少3位字符）
    if (account.length < 3) {
      wx.showToast({ title: '账号至少3位字符', icon: 'none' });
      return;
    }

    wx.showLoading({ title: '处理中...' });

    // 处理登录/注册
    this.processLoginOrRegister(account, password).then((result) => {
      wx.hideLoading();
      
      if (result.success) {
        // 登录/注册成功
        const userInfo = {
          userId: account,
          account: account,
          nickName: result.isNewUser ? `用户${account}` : result.userInfo.nickName,
          avatarUrl: result.userInfo ? result.userInfo.avatarUrl : '../../images/avatar.png',
          isLogin: true
        };
        
        // 保存用户信息
        wx.setStorageSync('userInfo', userInfo);
        
        // 更新全局数据
        const app = getApp();
        app.globalData.userInfo = userInfo;
        
        const message = result.isNewUser ? '注册并登录成功' : '登录成功';
        wx.showToast({ title: message, icon: 'success' });
        
        // 跳转到首页
        setTimeout(() => {
          this.redirectToHome();
        }, 1500);
        
      } else {
        wx.showToast({ title: result.message || '登录失败', icon: 'none' });
      }
    }).catch((error) => {
      wx.hideLoading();
      wx.showToast({ title: '登录失败，请重试', icon: 'none' });
    });
  },

  processLoginOrRegister(account, password) {
    try {
      // 使用本地存储，但提供默认用户数据
      const storageKey = 'badminton_users';
      
      // 读取用户数据
      let localUsers = wx.getStorageSync(storageKey);
      
      // 如果读取到的是字符串，尝试解析为JSON
      if (typeof localUsers === 'string') {
        try {
          // 检查字符串是否为空或只包含空白字符
          if (!localUsers || localUsers.trim() === '') {
            localUsers = null;
          } else {
            
            try {
                const parsedData = JSON.parse(localUsers);
                if (Array.isArray(parsedData)) {
                  // 验证数组内容
                  for (let i = 0; i < parsedData.length; i++) {
                    if (parsedData[i] && parsedData[i].account) {
                      // 验证用户账号存在
                    }
                  }
                }
              // 修复解析后数据类型仍然为string的问题
              if (typeof parsedData === 'string' && parsedData.trim().startsWith('[')) {
                try {
                  const reparsedData = JSON.parse(parsedData);
                  if (Array.isArray(reparsedData)) {
                    // 验证数组内容
                    for (let i = 0; i < reparsedData.length; i++) {
                      if (reparsedData[i] && reparsedData[i].account) {
                        // 验证用户账号存在
                      }
                    }
                  }
                  parsedData = reparsedData;
                } catch (reparseErr) {
                  // 再次解析失败
                }
              }
              localUsers = parsedData;
            } catch (parseErr) {
              // 尝试修复截断的JSON
              
              // 检查是否是截断的JSON数组
              if (localUsers.trim().startsWith('[')) {
                // 确保JSON字符串以正确的括号结束
                let fixedJson = localUsers.trim();
                
                // 如果没有以]结束，添加它
                if (!fixedJson.endsWith(']')) {
                  // 找到最后一个完整的对象
                  let lastCompleteObj = -1;
                  let braceCount = 0;
                  
                  for (let i = 0; i < fixedJson.length; i++) {
                    if (fixedJson[i] === '{') {
                      if (braceCount === 0) {
                        lastCompleteObj = i;
                      }
                      braceCount++;
                    } else if (fixedJson[i] === '}') {
                      braceCount--;
                      if (braceCount === 0 && i > lastCompleteObj) {
                        lastCompleteObj = i;
                      }
                    }
                  }
                  
                  if (lastCompleteObj > 0) {
                    // 截取到最后一个完整对象的位置
                    fixedJson = fixedJson.substring(0, lastCompleteObj + 1) + ']';
                    
                    try {
                      const fixedData = JSON.parse(fixedJson);
                      if (Array.isArray(fixedData)) {
                        // 验证数组内容
                        for (let i = 0; i < fixedData.length; i++) {
                          if (fixedData[i] && fixedData[i].account) {
                            // 验证用户账号存在
                          }
                        }
                      }
                      // 修复解析后数据类型仍然为string的问题
                      if (typeof fixedData === 'string' && fixedData.trim().startsWith('[')) {
                        try {
                          const reparsedData = JSON.parse(fixedData);
                          if (Array.isArray(reparsedData)) {
                            // 验证数组内容
                            for (let i = 0; i < reparsedData.length; i++) {
                              if (reparsedData[i] && reparsedData[i].account) {
                                // 验证用户账号存在
                              }
                            }
                          }
                          fixedData = reparsedData;
                        } catch (reparseErr) {
                          // 修复后再次解析失败
                        }
                      }
                      localUsers = fixedData;
                    } catch (fixErr) {
                      throw fixErr;
                    }
                  } else {
                    throw new Error('无法找到完整的JSON对象');
                  }
                } else {
                  throw parseErr;
                }
              } else {
                throw parseErr;
              }
            }
          }
        } catch (e) {
          // 如果JSON解析失败，尝试将字符串作为数组的一个元素
          try {
            // 检查字符串是否看起来像是一个用户对象
            if (localUsers.includes('account') && localUsers.includes('password')) {
              // 尝试提取可能的用户对象
              const userMatch = localUsers.match(/\{[^}]*\}/);
              if (userMatch) {
                try {
                  const userObj = JSON.parse(userMatch[0]);
                  if (userObj && userObj.account) {
                    localUsers = [userObj];
                  }
                } catch (e2) {
                  // 提取用户对象失败
                }
              }
            }
          } catch (e2) {
            // 尝试解析为单个用户失败
          }
        }
      }
      
      // 数据处理逻辑
      
      // 先声明userArray变量，确保作用域正确
      let userArray = [];
      
      // 初始化默认用户数据 - 修改条件判断，更严格地检查空数据
      // 只有在确实没有用户数据时才初始化默认用户
      if (!localUsers || 
          (Array.isArray(localUsers) && localUsers.length === 0) || 
          (typeof localUsers === 'object' && localUsers !== null && Object.keys(localUsers).length === 0) ||
          (typeof localUsers === 'string' && localUsers.trim() === '')) {
        const defaultUser = {
          "account": "demo",
          "password": "123456",
          "nickName": "演示用户",
          "avatarUrl": "../../images/avatar.png",
          "registerTime": "2025-07-31T02:00:00.000Z",
          "gender": "male"
        };
        
        // 设置默认用户到已声明的数组
        userArray = [defaultUser];
        
        // 使用JSON序列化确保数据格式正确
        try {
          const jsonData = JSON.stringify(userArray);
          // 使用JSON字符串形式保存，确保数据完整性
          wx.setStorageSync(storageKey, jsonData);
        } catch (e) {
          // 保存默认用户数据失败
        }
      } else {
        // 更健壮地处理localUsers，适应微信小程序环境
        
        // 尝试多种方式获取和验证数据
        if (localUsers && typeof localUsers === 'object') {
          try {
            // 首先尝试直接使用JSON序列化/反序列化，这能确保数据完整性
            try {
              const jsonStr = JSON.stringify(localUsers);
              const parsedArray = JSON.parse(jsonStr);
              
              if (Array.isArray(parsedArray)) {
                // 验证数组内容
                let validUsers = 0;
                for (let i = 0; i < parsedArray.length; i++) {
                  if (parsedArray[i] && parsedArray[i].account) {
                    validUsers++;
                  }
                }
                
                if (validUsers > 0) {
                  userArray = parsedArray;
                }
              }
            } catch (jsonError) {
                // 如果JSON处理失败，尝试其他方法
                if (Array.isArray(localUsers)) {
                  // 如果是标准数组，直接使用
                  userArray = localUsers;
                } else if (typeof localUsers.length === 'number') {
                  // 对于类数组对象，创建新数组并逐个复制元素
                  userArray = [];
                  for (let i = 0; i < localUsers.length; i++) {
                    if (localUsers[i] !== undefined) {
                      userArray.push(localUsers[i]);
                    }
                  }
                } else {
                  // 处理其他可能的对象类型
                  
                  // 最后的后备方案：尝试使用Object.values获取所有值
                  try {
                    const values = Object.values(localUsers);
                    if (values.length > 0) {
                      userArray = values;
                    }
                  } catch (e2) {
                    // Object.values也失败
                  }
                }
            }
          } catch (e) {
              // 处理localUsers时出错
            }
          } else {
            // localUsers不是对象或为null/undefined
          }
          
          // 如果userArray为空或无效，初始化默认用户
          if (!userArray || userArray.length === 0) {
          const defaultUser = {
            "account": "demo",
            "password": "123456",
            "nickName": "演示用户",
            "avatarUrl": "../../images/avatar.png",
            "registerTime": "2025-07-31T02:00:00.000Z",
            "gender": "male"
          };
          
          userArray = [defaultUser];
          
          // 保存默认用户数据 - 使用JSON字符串形式保存，确保数据完整性
          const defaultJsonString = JSON.stringify(userArray);
          wx.setStorageSync(storageKey, defaultJsonString);
        }
      }
      
      // 移除旧的localUsers数组检查，现在使用处理后的userArray
      
      // 打印每个用户账号的详细信息用于调试
      let foundIndex = -1;
      
      // 使用多种方式遍历数组
      for (let i = 0; i < userArray.length; i++) {
        const user = userArray[i];
        
        if (user && user.account !== undefined) {
          const storedAccount = String(user.account);
          const inputAccount = String(account);
          
          if (storedAccount === inputAccount) {
            foundIndex = i;
            break;
          }
        }
      }
      
      // 如果for循环没找到，尝试使用forEach
      if (foundIndex === -1) {
        userArray.forEach((user, index) => {
          if (foundIndex === -1 && user && user.account !== undefined) {
            const storedAccount = String(user.account);
            const inputAccount = String(account);
            
            if (storedAccount === inputAccount) {
              foundIndex = index;
            }
          }
        });
      }
      
      // 如果还是没找到，尝试使用Object.keys
      if (foundIndex === -1) {
        const keys = Object.keys(userArray);
        
        for (const key of keys) {
          if (foundIndex === -1) {
            const index = parseInt(key, 10);
            if (!isNaN(index)) {
              const user = userArray[key];
              if (user && user.account !== undefined) {
                const storedAccount = String(user.account);
                const inputAccount = String(account);
                
                if (storedAccount === inputAccount) {
                  foundIndex = index;
                }
              }
            }
          }
        }
      }
      
      // 使用更可靠的方式查找用户
      const existingUser = foundIndex >= 0 ? userArray[foundIndex] : null;
      
      if (existingUser) {
        // 用户已存在，验证密码
        if (existingUser.password === password) {
          return Promise.resolve({
            success: true,
            isNewUser: false,
            userInfo: existingUser,
            message: '登录成功'
          });
        } else {
          return Promise.resolve({
            success: false,
            message: '密码错误'
          });
        }
      } else {
        // 新用户，自动注册
        if (password.length >= 6) {
          const newUser = {
            account,
            password,
            nickName: `用户${account}`,
            avatarUrl: '../../images/avatar.png',
            registerTime: new Date().toISOString()
          };
          
          // 使用处理后的数组添加新用户
          userArray.push(newUser);
          
          try {
            // 确保userArray是标准数组格式
            const arrayToSave = Array.isArray(userArray) ? userArray : [];
            
            // 尝试使用JSON序列化确保数据格式正确
            try {
              const jsonData = JSON.stringify(arrayToSave);
              
              // 保存到本地存储 - 使用JSON字符串形式保存，确保数据完整性
              const jsonString = JSON.stringify(arrayToSave);
              wx.setStorageSync(storageKey, jsonString);
              
              // 立即验证
              try {
                const savedData = wx.getStorageSync(storageKey);
                // 数据验证逻辑
                
                // 尝试解析保存的数据
                try {
                  let parsedData;
                  // 如果savedData是字符串，直接解析JSON
                  if (typeof savedData === 'string') {
                    try {
                      parsedData = JSON.parse(savedData);
                    } catch (parseErr) {
                      // 如果解析失败，尝试修复JSON格式
                      try {
                        // 检查是否是截断的JSON
                        if (savedData.trim().endsWith(']') && savedData.trim().startsWith('[')) {
                          // 尝试手动修复可能的截断问题
                          const fixedJson = savedData.trim();
                          parsedData = JSON.parse(fixedJson);
                        } else {
                          throw new Error('JSON格式不正确');
                        }
                      } catch (fixErr) {
                        parsedData = null;
                      }
                    }
                  } else {
                    // 如果savedData不是字符串，先序列化再解析
                    parsedData = JSON.parse(JSON.stringify(savedData));
                  }
                  
                  // 修复解析后数据类型仍然为string的问题
                  if (typeof parsedData === 'string' && parsedData.trim().startsWith('[')) {
                    try {
                      const reparsedData = JSON.parse(parsedData);
                      parsedData = reparsedData;
                    } catch (reparseErr) {
                      // 再次解析失败
                    }
                  }
                  
                  if (parsedData && Array.isArray(parsedData) && parsedData.length > 0) {
                    // 验证数据内容
                    let allValid = true;
                    for (let i = 0; i < parsedData.length; i++) {
                      const user = parsedData[i];
                      if (!user || !user.account) {
                        allValid = false;
                      }
                    }
                    
                    if (allValid) {
                      // 延迟验证
                      setTimeout(() => {
                        try {
                          const delayedData = wx.getStorageSync(storageKey);
                          
                          // 如果是字符串，尝试解析JSON
                          if (typeof delayedData === 'string') {
                            try {
                              const parsedDelayedData = JSON.parse(delayedData);
                              
                              // 修复延迟验证解析后数据类型仍然为string的问题
                              if (typeof parsedDelayedData === 'string' && parsedDelayedData.trim().startsWith('[')) {
                                try {
                                  const reparsedData = JSON.parse(parsedDelayedData);
                                  parsedDelayedData = reparsedData;
                                } catch (reparseErr) {
                                  // 延迟验证再次解析失败
                                }
                              }
                              
                              if (Array.isArray(parsedDelayedData)) {
                                // 验证用户数据
                                for (let i = 0; i < parsedDelayedData.length; i++) {
                                  if (parsedDelayedData[i] && parsedDelayedData[i].account) {
                                    // 用户数据验证
                                  }
                                }
                              }
                            } catch (e) {
                              // 尝试修复JSON格式
                              try {
                                if (delayedData.trim().endsWith(']') && delayedData.trim().startsWith('[')) {
                                  const fixedJson = delayedData.trim();
                                  const fixedData = JSON.parse(fixedJson);
                                }
                              } catch (fixErr) {
                                // JSON修复失败
                              }
                            }
                          }
                        } catch (parseError) {
                          // 延迟验证失败
                        }
                      }, 1000);
                      return Promise.resolve({
                        success: true,
                        isNewUser: true,
                        userInfo: newUser,
                        message: '注册并登录成功'
                      });
                    } else {
                      return Promise.resolve({
                        success: false,
                        message: '数据内容验证失败'
                      });
                    }
                  } else {
                    return Promise.resolve({
                      success: false,
                      message: '数据保存失败'
                    });
                  }
                } catch (parseError) {
                  return Promise.resolve({
                    success: false,
                    message: '数据解析失败'
                  });
                }
              } catch (verifyError) {
                return Promise.resolve({
                  success: false,
                  message: '数据验证失败'
                });
              }
            } catch (jsonError) {
              return Promise.resolve({
                success: false,
                message: '数据处理失败'
              });
            }
          } catch (writeError) {
            return Promise.resolve({
              success: false,
              message: '保存用户数据失败'
            });
          }
        } else {
          return Promise.resolve({
            success: false,
            message: '密码长度至少6位'
          });
        }
      }
    } catch (error) {
      return Promise.resolve({
        success: false,
        message: '系统错误，请重试'
      });
    }
  },

  redirectToHome() {
    wx.reLaunch({
      url: '/pages/index/index'
    });
  },

  onBack() {
    wx.navigateBack({
      fail: () => {
        // 如果无法返回上一页，则跳转到我的页面
        wx.switchTab({
          url: '/pages/me/me'
        });
      }
    });
  }
});